
define([
        'Util',
        'text!tpl/gooflow/addGooflow.tpl',
        'select',
        'form',
        'dialog',
        'jquery',
        'validator',
        'loading',
        '../common/getPath',
        'style!../../css/gooflow/gooflow.css',
        '../common/components/gooflow/gooflow',
    ],
    function (Util, tpl, Select, Form, Dialog, $, Validator, Loading, AjaxPath, gooflowStyle, gooflow) {
        require(['style!css/style.css']);
        //系统变量-定义该模块的根节点
        var $el = null;
        var _indexModule = null,
            tabParent = null,
            addGooflow = null,
            addGooflowLoadingConfig = null,
            flowLoading = null;
            addSceneSelect = null,
            addStatusSelect = null,
            addStatusValidation = null,
            addGooglowValidation = null,
            addWorkflowBox = null,
            addProperty = null,
            addFlowJsondata = null,
            addStatusAdddialog = null,
            addToolBtnsArr = null;
            addToolBtnNames = null,
            addSaveGooflowData = null,
            addToolBtnDescription = null;

        //系统变量-构造函数
        var initialize = function(indexModule, options, tabItem) {
            $el = $(tpl);
            _indexModule = indexModule;
            $(tabItem).on("tabActive", function() {
                tabItem.show(true); //刷新表单
            });

            createLoading();
            addGooflow = options;
            tabParent = tabItem;
            eventInit();
            this.content = $el;
            inSelect();
            inAddGooflow();
            GooflowValidation();
            forbidEnterAddFlow();
        };

        //业务代码-事件初始化
        var eventInit = function() {
            $el.on('click', '.btnSave', saveGooflowValidation);
            $el.on('click', '.btnBack', back);
            $el.on('click', '#statusAdd', statusAdd);
            $el.on('click', '#actAdd', actAdd);
        };
        var forbidEnterAddFlow = function() {
            $("input[name='flowTitle']", $el).on('keypress', function(e){
               if(e.keyCode === 13){
                    e.preventDefault();
                    return false;
                }
            });
            $(document).on('keypress', "input[name='name']", function(e){
               if(e.keyCode === 13){
                    e.preventDefault();
                    return false;
                }
            });
        }
        var back = function() {
            tabParent.switchTab(addGooflow.menuId);
            tabParent.destroy("addGooflowTab");
        };
        //增加状态弹框
        var statusAdd= function () {
            require(['text!tpl/gooflow/addStatus.tpl'], function (addStatusTpl) {
                var statusAddConfig = {
                    title: '增加状态', //对话框标题，
                    modal:true,
                    content: addStatusTpl, //对话框内容，可以是字符串、html代码段,tpl对象。默认为loading状态（由点组成的圈。大段代码建议使用 tpl。
                    ok: function() {//  增加状态
                        if(addSceneSelect.getSelected().key === undefined){
                            new Dialog({
                                mode: 'tips',
                                delayRmove:1.5, //延迟删除秒数设定 tips默认3秒,非tips默认不关闭。
                                tipsType:'tips', //tips类型；可选 success | error，默认普通tips。
                                maxWidth:'226px', //设置tips对话框的最大宽度,默认为226px。仅在tips对话框下生效，该项存在时，width属性将失效。
                                content: '请选择一个场景！'
                            });
                            return false;
                        }
                        if(addStatusValidation.form()) {
                            var key = addSceneSelect.getSelected().key;
                            var saveStatusConfig = {
                                    mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                                    title:'提示',
                                    width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                                    height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                                    cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                                    modal:true,
                                    content: '' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                                },
                                saveStatusDialog = null;
                            var saveStatusData = Form.serialize($('.addGooflowStatusForm'));
                            saveStatusData.description = saveStatusData.description.trim();

                            Util.ajax.postJson(AjaxPath.project + '/workFlows/'+key+'/nodes', saveStatusData, function(result, isok) {
                                if(result.returnCode==="0000") {
                                    saveStatusConfig.content = '<div style="text-align:center;margin-top:50px">添加状态成功</div>'
                                    saveStatusDialog = new Dialog(saveStatusConfig);
                                    reloadStatus(key,true);
                                    return true;
                                } else {
                                    saveStatusConfigContent = '添加状态失败';
                                    if(result.returnMessage){
                                        saveStatusConfigContent = result.returnMessage;
                                    }
                                    saveStatusConfig.content = '<div style="text-align:center;margin-top:50px">'+saveStatusConfigContent+'</div>'
                                    saveStatusDialog = new Dialog(saveStatusConfig);
                                }
                            });
                            console.log('验证通过==保存新增状态')
                        } else {
                            console.log('验证失败');
                            return false;
                        }
                    },
                    okValue: '保&nbsp;&nbsp;存', //确定按钮的文本 默认是 ‘ok’
                    cancel: function() {},
                    cancelValue: '返&nbsp;&nbsp;回', //取消按钮的文本 默认是 ‘关闭’
                    width: 400,
                    height: 190
                };
                addStatusAdddialog = new Dialog(statusAddConfig);

                StatusValidation();
            })

        };

        //增加状态到状态栏
        var StatusValidation = function() {
            addStatusValidation = new Validator({
                el: $(".addGooflowStatusForm"),
                dialog: true, //是否弹出验证结果对话框
                rules: {
                    name: "required"
                },
                messages: {
                    name: {
                        required: "状态名称不能为空！"
                    }
                }
            });
        };


        //增加动作
        var actAdd= function () {
            console.log('增加动作')
        };

        var switchTab = function(index) {
            $(".t-tabs-items li", $el).eq(index).trigger('click');
        };

        var inSelect = function() {
            var flowConTip = {
                mode: 'tips',
                delayRmove:1.5, //延迟删除秒数设定 tips默认3秒,非tips默认不关闭。
                tipsType:'success', //tips类型；可选 success | error，默认普通tips。
                maxWidth:'226px', //设置tips对话框的最大宽度,默认为226px。仅在tips对话框下生效，该项存在时，width属性将失效。
                content: ''
            };

            var dialog = null;

            //获取场景下拉
            Util.ajax.getJson(AjaxPath.project+"/dropdown?modual=dataWorkFlow&type=useMode", {}, function(result, isok){
                if(result.returnCode==="0000") {
                    addSceneSelect = new Select({
                        el:$("#sceneList", $el),       //要绑定的容器
                        ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                            method:'GET'
                        },
                        label:'<i style="color:red;padding:2px;">*</i>场景:', //下拉框单元左侧label文本，可不配置
                        selectText:false,       //是否显示  ‘选择|清除’  模式
                        name:'useMode',    //下拉框单元右侧下拉框名称
                        disabled:false,     //组件是否被禁用
                        topOption:"请选择", //设置最顶部option的text属性
                        value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                        textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                        valueField:"key",//设置下拉框value，填写数据中对应的字段名
                        datas: result.beans,         //数据源
                        loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                        dataReady:function(){
                            console.log("获取场景。。。");
                        }
                    });
                    addSceneSelect.setValue(addGooflow.dropActive);
                    //这样注册change事件
                    addSceneSelect.on("change",function(e,valueObj){
                        if(!(valueObj.key === undefined)){
                            reloadStatus(valueObj.key,false);
                            addFlowJsondata = {
                                "title": "",
                                "nodes": {
                                    "start_-1_node_0": {
                                        "name": "开始",
                                        "left": 80,
                                        "top": 35,
                                        "type": "start_-1 round",
                                        "width": 24,
                                        "height": 24,
                                        "alt": true
                                    },
                                    "end_-9_node_0": {
                                        "name": "结束",
                                        "left": 178,
                                        "top": 36,
                                        "type": "end_-9 round",
                                        "width": 24,
                                        "height": 24,
                                        "alt": true
                                    }
                                },
                                "lines": {},
                                "areas": {},
                                "initNum": 9
                            };

                        }
                    });
                }else{
                    flowConTip.content = '获取场景下拉失败';
                    dialog = new Dialog(flowConTip);
                }

            });
            //获取状态下拉
            Util.ajax.getJson( AjaxPath.project + "/dropdown?modual=dataWorkFlow&type=flowStatus", {}, function(result, isok){
                if(result.returnCode==="0000"){
                    addStatusSelect = new Select({
                        el:$("#gooflowStatus", $el),       //要绑定的容器
                        ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                            method:'GET'
                        },
                        label:'<i style="color:red;padding:2px;">*</i>状态:', //下拉框单元左侧label文本，可不配置
                        selectText:false,       //是否显示  ‘选择|清除’  模式
                        name:'flowStatus',    //下拉框单元右侧下拉框名称
                        disabled:false,     //组件是否被禁用
                        topOption:"请选择", //设置最顶部option的text属性
                        value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                        textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                        valueField:"key",//设置下拉框value，填写数据中对应的字段名
                        datas: result.beans,         //数据源
                        loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                        dataReady:function(){
                            console.log("获取项目状态");
                        }
                    });
                    addStatusSelect.setValue(0);
                }else{
                    flowConTip.content = '获取状态下拉失败';
                    dialog = new Dialog(flowConTip);
                }
            })

        };
        //级连左侧状态栏
        function reloadStatus(key, type) {
            Util.ajax.getJson( AjaxPath.project + '/workFlows/'+key+'/nodes', {}, function(result, isok){
                if (result.returnCode === "0000") {
                    addToolBtnsArr = ["start_-1 round", "end_-9 round"];
                    addToolBtnNames = ["开始", "结束"];
                    addToolBtnDescription = ["", ""];

                    $(result.beans).each(function(index, item) {
                        addToolBtnsArr.push('stage_' + item.key);
                        addToolBtnNames.push($("<span/>").text(item.value.trim()).html());
                        addToolBtnDescription.push($("<span/>").text(item.description).html());//title描述
                    });
                    
                    if (type) {
                        addWorkflowBox.resetToolBtn({
                            toolBtns: addToolBtnsArr,
                            toolBtnNames: addToolBtnNames,
                            toolBtnDescription: addToolBtnDescription
                        });
                    } else {
                        addProperty.toolBtns = addToolBtnsArr;
                        addProperty.toolBtnNames = addToolBtnNames;
                        addProperty.toolBtnDescription = addToolBtnDescription;
                        $("#addFlowBox").html('');
                        gooFlow();
                    }
                } else {
                    console.log('reloadStatus失败');
                }
            })
        };
        //inGooflow
        var inAddGooflow = function() {
            // addToolBtnsArr = ["start_-1 round", "end_-9 round"];
            // addToolBtnNames = ["开始", "结束"];
            addProperty = {
                width: $(window).width()-60,
                height: 600,
                toolBtns: addToolBtnsArr,
                toolBtnNames: addToolBtnNames,
                toolBtnDescription: addToolBtnDescription,
                haveHead: true, //是否显示顶部
                // headBtns: ["new", "open", "save", "undo", "redo", "reload"], //如果haveHead=true，则定义HEAD区的按钮
                headBtns: ["undo", "redo",], //如果haveHead=true，则定义HEAD区的按钮
                haveTool: true, //是否显示左侧
                // haveGroup: true,
                useOperStack: true,
            };

            addFlowJsondata = {
                "title": "",
                "nodes": {
                    "start_-1_node_0": {
                        "name": "开始",
                        "left": 80,
                        "top": 35,
                        "type": "start_-1 round",
                        "width": 24,
                        "height": 24,
                        "alt": true
                    },
                    "end_-9_node_0": {
                        "name": "结束",
                        "left": 178,
                        "top": 36,
                        "type": "end_-9 round",
                        "width": 24,
                        "height": 24,
                        "alt": true
                    }
                },
                "lines": {},
                "areas": {},
                "initNum": 9
            };
            gooFlow();
            reloadStatus(addGooflow.dropActive, false);
        };
        var gooFlow = function () {
            addWorkflowBox = $.createGooFlow($("#addFlowBox", $el), addProperty);
            addWorkflowBox.loadData(addFlowJsondata);
            addWorkflowBox.delToolChild(delToolChild);
        }

        var delToolChild = function(e){
            var useModeId = addSceneSelect.getSelected("key");
            var toolChildId = e.parent("a").attr("type").split("_")[1];
            
            Util.ajax.getJson(AjaxPath.project + '/workFlows/deleteNode/' + useModeId + '/' +toolChildId, {}, function(result, isok){
                if(result.returnCode==="0000"){
                    e.parent("a").remove();
                }
            })
        }

        //提交验证
        var GooflowValidation = function() {
            addGooglowValidation = new Validator({
                el: $(".addGooflowForm", $el),
                submitBtn: $(".btnSave"), //触发验证的按钮，可不配置
                dialog: true, //是否弹出验证结果对话框
                rules: {
                    flowTitle: "required",
                    useMode: "required",
                    flowStatus: 'required',
                },
                messages: {
                    flowTitle: {
                        required: "工作流名称不能为空！"
                    },
                    useMode: {
                        required: "场景不能为空！"
                    },
                    flowStatus: {
                        required: "工作流状态不能为空！"
                    }
                }
            });
        };

        var saveGooflowValidation = function() {
            if(addGooglowValidation.form()) {
                var nameFlag = true;
                var arrLine = [];
                var arrNode = [];
                addSaveGooflowData = Form.serialize($('.addGooflowForm'));
                addSaveGooflowData.viewJson = JSON.stringify(addWorkflowBox.exportData());
                //判断连线名称必填=====未判断开始和结束连线
                var nodes = addWorkflowBox.exportData().nodes;
                for(var item in nodes){
                    arrNode.push(item);
                }
                var lines = addWorkflowBox.exportData().lines;
                for(line in lines){
                    arrLine.push(lines[line]);
                }
                
                $(arrNode).each(function(index, n){
                    var arrLineStr = "";
                    if(arrLine.length>0){
                        for(var i=0;i<arrLine.length;i++){
                            arrLineStr += arrLine[i].from + ',' + arrLine[i].to;
                            if(arrLine[i].from != 'start_-1_node_0'){
                                if(arrLine[i].name === ''){
                                    nameFlag = false;
                                    break;
                                }
                            }
                        }

                        if(arrLineStr.indexOf($(arrNode)[index])<= -1){
                            nameFlag = false;
                            return;
                        }
                    }else{
                        nameFlag = false;
                        return;
                    }

                })    
                if(nameFlag !== false){
                    //判断是否为在用状态
                    if(addStatusSelect.getSelected().key === 1){
                        var statusLoading = new Loading(addGooflowLoadingConfig);
                        Util.ajax.postJson(AjaxPath.project + '/workFlows/checkStatus', addSaveGooflowData, function(result, isok) {
                            statusLoading.destroy();
                            if(result.returnCode==="0000") {
                                var useModeType = addSceneSelect.getSelected('key');
                                var useModeStr = '';
                                if(useModeType=='51'){
                                    useModeStr = "需求、子任务";
                                }else if(useModeType=='62'){
                                    useModeStr = "项目";
                                }else if(useModeType=='9'){
                                    useModeStr = "用例";
                                }else if(useModeType=='4'){
                                    useModeStr = "缺陷";
                                };
                                if(result.beans.useCount === 1){
                                    new Dialog({
                                        mode: 'confirm',
                                        id: 'confirmId',
                                        title: '提示',
                                        content: '<p style="padding: 10px 25px;">使用原有工作流的'+ useModeStr +'的状态在切换工作流后将不能自动更新为当前工作流中的状态，需要手动修改，确认要选用此工作流？</p>',
                                        ok: function() {
                                            saveGooflow();
                                            return true;
                                        }, // 点击确定按钮的回调函数，可为空。如果指定 return false 则执行完方法后不关闭对话框，默认 return true。若不配置该项，则不会出现确定按钮。
                                        okValue: '确定', //确定按钮的文本 默认是 ‘ok’
                                        cancel: function() {
                                            return true;
                                        }, // 点击取消按钮的回调函数，可为空。如果指定 return false 则执行完方法后不关闭对话框，默认 return true。若不配置该项，则不会出现取消按钮。
                                        cancelValue: '取消', //取消按钮的文本 默认是 ‘关闭’
                                        cancelDisplay: true, //是否显示取消按钮 默认true显示|false不显示
                                        width: 400, //对话框宽度，normal默认值为600，confirm默认值为300，tips默认值为240
                                        height: 100,
                                    });

                                }else{
                                    saveGooflow();
                                }
                            } else {
                                console.log('判断是否为在用状态失败')
                            }
                        });
                    }else{
                        saveGooflow();
                    }
                }else{
                    new Dialog({
                        mode: 'normal',
                        title: '提示',
                        content: '请为添加的节点连接至少一条线,并为除开始与结束之外的连线起名！',
                        ok: function() {
                            console.log('点击了确定按钮') 
                            return true;
                        }, // 点击确定按钮的回调函数，可为空。如果指定 return false 则执行完方法后不关闭弹窗，默认 return true。若不配置该项，则不会出现确定按钮。
                        okValue: '确定', //确定按钮的文本 默认是 ‘ok’
                        cancelDisplay: true, //是否显示取消按钮 默认true显示|false不显示  
                        width: 300, //弹窗宽度，normal默认值为600，confirm默认值为300
                        height: 80, //弹窗高度，normal默认值为400，confirm默认值为180  
                        maxWidth: '226px', //设置tips对话框的最大宽度,默认为226px。仅在tips对话框下生效，该项存在时，width属性将失效。
                        padding:'0 16px 1em 10px',//(默认值: 继承 css 文件设置) 设置消息内容与消息容器的填充边距，即 style padding属性；仅在normal标准弹窗中生效；
                        align: 'bottom left',//设置弹窗与其他元素的对齐方式。仅在show(elem)与showModal(elem)传入元素时生效。默认值: "bottom left"。可选："top left" "top" "top right" "right top" "right" "right bottom" "bottom right" "bottom" "bottom left" "left bottom" "left" "left top"。
                        skin: 'dialogSkin dialogSkin2',//设置弹窗额外的className参数,多个className请使用空格隔开。
                        fixed: false, //是否开启固定定位 normal标准弹窗默认false不开启；confirm弹窗默认状态为true开启
                        quickClose: false, //点击空白处快速关闭 默认false不关闭|true关闭
                        modal: true ,//是否开启模态框状态，即背景遮罩。默认false不开启|true开启,confirm弹窗默认状态为true
                        backdropBackground:'#000',//设置遮罩颜色，默认 #000。
                        backdropOpacity:0.4, //设置遮罩透明度，默认 0.4，取值范围：0~1 。
                        beforeOpen: function() {console.log('弹窗打开时执行。')}, //弹窗打开之前执行。
                        escClose:true,//esc键快速关闭弹窗，默认为true
                        zIndex:990   // 弹窗的z-index值，默认是1024。
                    });
                }
            } else {
                console.log('验证失败');
            }
        };
        //保存工作流
        var saveGooflow=function () {
            var saveflowLoading = new Loading(addGooflowLoadingConfig);
            var saveGooflowConfig = {
                    mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                    title:'提示',
                    width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                    height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                    cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                    modal:true,
                    content: '' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                },
                saveGooflowDialog = null;
            Util.ajax.postJson(AjaxPath.project + '/workFlows', addSaveGooflowData, function(result, isok) {
                saveflowLoading.destroy();
                if(result.returnCode==="0000") {
                    saveGooflowConfig.content = '<div style="text-align:center;margin-top:50px">新增工作流成功！</div>'
                    saveGooflowDialog = new Dialog(saveGooflowConfig);
                    saveGooflowDialog.on('onclose',function(){
                        back();
                    });
                } else {
                    saveStatusConfigContent = '新增工作流失败';
                    if(result.returnMessage){
                        saveStatusConfigContent = result.returnMessage;
                    }
                    saveGooflowConfig.content = '<div style="text-align:center;margin-top:50px">'+saveStatusConfigContent+'</div>'
                    saveStatusDialog = new Dialog(saveGooflowConfig);
                }
            });
        };

        var createLoading = function(){
            addGooflowLoadingConfig = {
                el:'body',                  //组件要绑定的容器，默认为body（此项可不配置或留空）
                className:'loading',           //组件外围的className
                position:'center',      //提示信息位置，顶部top|默认center中央
                width:'300',      //loading的宽度,非必须，默认300
                height:'auto',      //loading的宽度,非必须，默认auto
                mask:1,                 //是否显示遮罩， 0不显示|默认1显示
                animate:1,              //是否显示动画效果， 0不显示|默认1显示
                mode:'layer',     //展示方式 loadingLine线条方式|默认layer弹层方式
                text:'加载中...',       //提示文字，默认 加载中...
                icon:'dotCycle',  //文字前面的gif动画， 默认dotCycle有点组成的圈|cmcc移动图标|cmccLarge大的移动图标
            }
        };
        return initialize;
    });

